<!DOCTYPE html>
<html>
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
		<title>Opal</title>
		<link rel="stylesheet" href="web/stylesheets/reset.css"/>
		<link rel="stylesheet" href="web/stylesheets/jmodel.css"/>
	</head>
	<body>

		<h1>Opal</h1>
		
		<article>
		    
		    <h1>Function</h1>
	        
		</article>
		
		<article>
		    
		    <h1>Function.prototype</h1>
		    
		    <section>
		        <h1>Property methods</h1>
		        <dl>
		            
		            <dt>
		                <span class="object">fn</span>.as
		                <ul class="arguments">
    				        <li>name</li>
    				    </ul>
    				    <span class="return">fn</span>
		            </dt>
		            
		            <dt>
		                <span class="object">fn</span>.extend
		                <ul class="arguments">
    				        <li>properties</li>
    				    </ul>
    				    <span class="return">fn</span>
		            </dt>
		            
    		    </dl>
	        </section>
	        
	        <section>
		        <h1>Application methods</h1>
		        <dl>
		            
		            <dt>
		                <span class="object">fn</span>.bind
		                <ul class="arguments unbounded">
    				        <li>context</li>
							<li class="optional">a</li>
    				        <li class="optional">b</li>
    				        <li class="optional">c</li>
    				    </ul>
    				    <span class="return">function</span>
		            </dt>
		            
		            <dt>
		                <span class="object">fn</span>.curry
		                <ul class="arguments unbounded">
    				        <li>a</li>
    				        <li>b</li>
    				        <li>c</li>
    				    </ul>
    				    <span class="return">function</span>
		            </dt>
		            
		            <dt>
		                <span class="object">fn</span>.memo
		                <ul class="arguments">
		                    <li/>
		                </ul>
    				    <span class="return">function</span>
		            </dt>
		            
		            <dt>
		                <span class="object">fn</span>.delay
		                <ul class="arguments unbounded">
    				        <li>duration</li>
							<li class="optional">a</li>
    				        <li class="optional">b</li>
    				        <li class="optional">c</li>
    				    </ul>
    				    <span class="return">function</span>
		            </dt>
		            
    		    </dl>
	        </section>
	
			<section>
				<h1>Mapping methods</h1>
				<dl>
					
					<dt>
		                <span class="object">fn</span>.map
		                <ul class="arguments">
    				        <li>mapping</li>
    				    </ul>
    				    <span class="return">function</span>
		            </dt>
					
				</dl>
			</section>
	        
	        <section>
		        <h1>Predicate methods</h1>
		        <dl>
		            
		            <dt>
		                <span class="object">fn</span>.is
		                <ul class="arguments">
    				        <li>pr</li>
    				    </ul>
    				    <span class="return">(<span class="multiple">value</span> <span class="return">boolean</span>)</span>
		            </dt>
		            
		            <dt>
		                <span class="object">fn</span>.neq
		                <ul class="arguments">
    				        <li>value</li>
    				    </ul>
    				    <span class="return">(<span class="multiple">value</span> <span class="return">boolean</span>)</span>
		            </dt>
		            
		            <dt>
		                <span class="object">fn</span>.lt
		                <ul class="arguments">
    				        <li>value</li>
    				    </ul>
    				    <span class="return">(<span class="multiple">value</span> <span class="return">boolean</span>)</span>
		            </dt>
		            
		            <dt>
		                <span class="object">fn</span>.gt
		                <ul class="arguments">
    				        <li>value</li>
    				    </ul>
    				    <span class="return">(<span class="multiple">value</span> <span class="return">boolean</span>)</span>
		            </dt>
		            
		            <dt>
		                <span class="object">fn</span>.lte
		                <ul class="arguments">
    				        <li>value</li>
    				    </ul>
    				    <span class="return">(<span class="multiple">value</span> <span class="return">boolean</span>)</span>
		            </dt>
		            
		            <dt>
		                <span class="object">fn</span>.gte
		                <ul class="arguments">
    				        <li>value</li>
    				    </ul>
    				    <span class="return">(<span class="multiple">value</span> <span class="return">boolean</span>)</span>
		            </dt>
		            
		            <dt>
		                <span class="object">fn</span>.between
		                <ul class="arguments">
    				        <li>lower</li>
    				        <li>higher</li>
    				    </ul>
    				    <span class="return">(<span class="multiple">value</span> <span class="return">boolean</span>)</span>
		            </dt>
		            
		            <dt>
		                <span class="object">fn</span>.matches
		                <ul class="arguments">
    				        <li>regex</li>
    				    </ul>
    				    <span class="return">(<span class="multiple">value</span> <span class="return">boolean</span>)</span>
		            </dt>
		            
		            <dt>
		                <span class="object">fn</span>.isnull
		                <ul class="arguments">
    				        <li/>
    				    </ul>
    				    <span class="return">(<span class="multiple">value</span> <span class="return">boolean</span>)</span>
		            </dt>
		            
		            <dt>
		                <span class="object">fn</span>.isa
		                <ul class="arguments">
    				        <li>constructor</li>
    				    </ul>
    				    <span class="return">(<span class="multiple">value</span> <span class="return">boolean</span>)</span>
		            </dt>
		            
		            <dt>
		                <span class="object">fn</span>.hastype
		                <ul class="arguments">
    				        <li>type</li>
    				    </ul>
    				    <span class="return">(<span class="multiple">value</span> <span class="return">boolean</span>)</span>
		            </dt>
		            
    		    </dl>
	        </section>
	
			<section>
		        <h1>Ordering methods</h1>
				<dl>
				
					<dt>
		                <span class="object">fn</span>.asc
		                <ul class="arguments">
    				    </ul>
    				    <span class="return">( (value,value) <span class="return">{-1,0,1}</span> )</span>
		            </dt>
		
					<dt>
		                <span class="object">fn</span>.desc
		                <ul class="arguments">
    				    </ul>
    				    <span class="return">( (value,value) <span class="return">{-1,0,1}</span> )</span>
		            </dt>
				
				</dl>
			</section>
	        
		</article>
		
		<article>
		    
		    <h1>Object</h1>
		    
		    <section>
	            <h1>Construction</h1>
	            <dl>

    		        <dt>
    	                Object.construct
    	                 <ul class="arguments unbounded">
        				    <li>constructor</li>
    				        <li class="optional">a</li>
    				        <li class="optional">b</li>
    				        <li class="optional">c</li>
    				    </ul>
    				    <span class="return">(<span class="multiple">value</span> <span class="return">object</span>)</span>
    	            </dt>
					<dd><p><code>Object.construct</code> wraps the <code>new</code> operator in a function. Arguments to the constructor can be passed at definition-time or application-time, but no more than ten arguments in total.</p></dd>
					<dd class="example">
						<p>
							<code>
								Object.construct(Date)('1997-8-29');
							</code>
							<br/><span class="output"><code>"Fri Aug 29 1997 00:00:00 GMT+0100 (BST)"</code></span>
						</p>
						<p>
							<code>
								Object.construct(Date)('1997-8-29') instanceof Date;
							</code>
							<br/><span class="output"><code>true</code></span>
						</p>
						<p>
							<code>
								function Employee (department, forename, surname) {			<br/>
									&#160;&#160;&#160;&#160;this.department = department;	<br/>
									&#160;&#160;&#160;&#160;this.forename = forename;		<br/>
									&#160;&#160;&#160;&#160;this.surname = surname			<br/>
								}
								<br/>
								var makeITstaff = Object.construct(Employee,'IT');
							</code>
						</p>
						<p>
							<code>
								var john = makeITstaff('John','Smith'); <br/>
								john.department;
							</code>
							<br/><span class="output"><code>"IT"</code></span>
							<br/><code>john.surname;</code>
							<br/><span class="output"><code>"Smith"</code></span>
						</p>
					</dd>

    	            <dt>
    	                Object.ensure
    	                <ul class="arguments unbounded">
        				    <li>constructor</li>
							<li class="optional">a</li>
    				        <li class="optional">b</li>
    				        <li class="optional">c</li>
    				    </ul>
    				    <span class="return">(<span class="multiple">value</span> <span class="return">object</span>)</span>
    	            </dt>

    		    </dl>
	        </section>
	        
	        <section>
	            <h1>Bare objects</h1>
	            <dl>
	                
					<dt>
    	                Object.copy
    	                <ul class="arguments">
    				        <li>object</li>
    				    </ul>
    				    <span class="return">object</span>
    	            </dt>

					<dt>
    	                Object.equal
    	                <ul class="arguments">
    				        <li>a</li>
							<li>b</li>
    				    </ul>
    				    <span class="return">boolean</span>
    	            </dt>

					<dt>
    	                Object.remove
    	                <ul class="arguments unbounded">
    				        <li>a</li>
    				        <li>b</li>
    				        <li>c</li>
    				    </ul>
    				    <span class="return">(object <span class="return">object</span>)</span>
    	            </dt>
	
	                <dt>
    	                Object.project
    	                <ul class="arguments unbounded">
    				        <li>a</li>
    				        <li>b</li>
    				        <li>c</li>
    				    </ul>
    				    <span class="return">(object <span class="return">object</span>)</span>
    	            </dt>

					<dt>
    	                Object.rename
    	                <ul class="arguments">
    				        <li>renaming</li>
    				    </ul>
    				    <span class="return">(object <span class="return">object</span>)</span>
    	            </dt>

					<dt>
    	                Object.union
    	                <ul class="arguments unbounded">
    				        <li>a</li>
    				        <li>b</li>
    				        <li>c</li>
    				    </ul>
    				    <span class="return">object</span>
    	            </dt>

					<dt>
    	                Object.difference
    	                <ul class="arguments">
    				        <li>a</li>
    				        <li>b</li>
    				    </ul>
    				    <span class="return">object</span>
    	            </dt>

					<dt>
    	                Object.join
    	                <ul class="arguments">
    				        <li>predicate</li>
    				    </ul>
    				    <span class="return">(<span class="multiple">object</span> <span class="return">object</span>)</span>
    	            </dt>
	                
	            </dl>
	        </section>
		    
		    <section>
		        <h1>Accessors</h1>
		        <dl>
		        
					<dt>
    	                Object.keys
    	                <ul class="arguments">
							<li>object</li>
    				    </ul>
    				    <span class="return">array</span>
    	            </dt>
		
					<dt>
    	                Object.get
    	                <ul class="arguments">
        				    <li>name</li>
							<li>object</li>
    				    </ul>
    				    <span class="return">value</span>
    	            </dt>

					<dt>
    	                Object.set
    	                <ul class="arguments">
        				    <li>name</li>
							<li>value</li>
							<li>object</li>
    				    </ul>
    				    <span class="return">boolean</span>
    	            </dt>

					<dt>
    	                Object.extend
    	                <ul class="arguments">
							<li>object</li>
							<li>properties</li>
    				    </ul>
    				    <span class="return">object</span>
    	            </dt>
		
		            <dt>
    	                Object.property
    	                <ul class="arguments">
        				    <li>name</li>
    				    </ul>
    				    <span class="return">(object <span class="return">value</span>)</span>
    	            </dt>
    	            
    	            <dd><p><code>Object.property(name)</code> is a function that returns an object's value for the named property.</p></dd>
    				<dd class="example">
    					<p>
    						<code>Object.property('forename')({forename:'john',surname:'smith'});</code>
    						<br/><span class="output"><code>"john"</code></span>
    					</p>
    				</dd>

					<dt>
						Object.property
    	                <ul class="arguments">
        				    <li>name</li>
    				        <li>value</li>
    				    </ul>
    				    <span class="return">(object <span class="return">object</span>)</span>
					</dt>
    				<dd><p><code>Object.property(name,value)</code> is a function that sets the named property to <code>value</code>.</p></dd>
    				<dd class="example">
    				    <p>
    						<code>
    						    var person = {forename:'john',surname:'smith'};
    						    <br/>Object.property('forename','jack')(person);
    						</code>
    						<br/><span class="output"><code>person</code></span>
    						<br/><code>person.forename</code>
    						<br/><span class="output"><code>"jack"</code></span>
    					</p>
    				</dd>
    	            
    	            <dt>
    	                Object.method
    	                <ul class="arguments unbounded">
        				    <li>name</li>
    				        <li class="optional">a</li>
    				        <li class="optional">b</li>
    				        <li class="optional">c</li>
    				    </ul>
    				    <span class="return">(object <span class="return">value</span>)</span>
    	            </dt>
    	            <dd><p><code>Object.method(name)</code> is a function that invokes the named method on an object. Additional arguments can be provided at suspension time but not at invocation time.</p> <p><code>Object.method('method',a,b,c)(object)</code> is equivalent to <code>object.method(a,b,c,d,e,f)</code>.</p></dd>
    				<dd class="example">
    					<p>
    						<code>Object.method('split','-')('john-smith');</code>
    						<br/><span class="output"><code>["john","smith"]</code></span>
    					</p>
    				</dd>
    	            
    	            <dt>
    	                Object.resolve
    	                <ul class="arguments unbounded">
        				    <li>name</li>
    				        <li class="optional">a</li>
    				        <li class="optional">b</li>
    				        <li class="optional">c</li>
    				    </ul>
    				    <span class="return">(object <span class="return">value</span>)</span>
    	            </dt>
    	            
    	            <dt>
    	                Object.path
    	                <ul class="arguments">
        				    <li>elements</li>
    				        <li class="optional">separator</li>
    				    </ul>
    				    <span class="return">(object <span class="return">value</span>)</span>
    	            </dt>
    	            <dd><p><code>Object.path</code> returns a function that dereferences a path on an object. The path can be specified as either an array of elements or a string specifying the elements. In the latter case, an optional separator can also be passed (the default is the ‘.’ character). If any element of the path is a method then the method will be invoked during dereferencing.</p></dd>
    				<dd class="example">
    				    <p>
    						<code>Object.path(['name','last'])({name:{first:'john',last:'smith'},age:27});</code>
    						<br/><span class="output"><code>"smith"</code></span>
    					</p>
    					<p>
    						<code>Object.path('name.last')({name:{first:'john',last:'smith'},age:27});</code>
    						<br/><span class="output"><code>"smith"</code></span>
    					</p>
    					<p>
    						<code>Object.path('name/last','/')({name:{first:'john',last:'smith'},age:27});</code>
    						<br/><span class="output"><code>"smith"</code></span>
    					</p>
    				</dd>
    	            
    	            <dt>
    	                Object.transform
    	            </dt>
		        
		        </dl>
		    </section>
		    
		    
		</article>
		
		<article>
		    
		    <h1>Function functions</h1>
		    <dl>
		        
		        <dt>
	                parallel
	            </dt>
	            
	            <dt>
	                bind
	            </dt>
	            
	            <dt>
	                apply
	                <ul class="arguments">
				        <li>fn</li>
				    </ul>
				    <span class="return">value</span>
	            </dt>
	            <dd><p><code>apply</code> applies a function, so that <code>apply(fn)</code> is equivalent to <code>fn()</code>.</p></dd>
	            
	            <dt>
	                applyto
	                <ul class="arguments unbounded">
				        <li>a</li>
				        <li>b</li>
				        <li>c</li>
				    </ul>
				    <span class="return">(function <span class="return">value</span>)</span>
	            </dt>
	            <dd><p>Given arguments <code>a,b,c...</code>, <code>applyto</code> creates a function that when called on a second function applies the second function to the provided arguments, so that <code>applyto(a,b,c...)(fn)</code> is equivalent to <code>fn(a,b,c...)</code>.</p></dd>
	            
		    </dl>
		    
		</article>
		
		<article>
		    
		    <h1>Reduction functions</h1>
		    <dl>
		        
		        <dt>
	                plus
	                <ul class="arguments">
				        <li>acc</li>
				        <li>x</li>
				    </ul>
				     <span class="return">value</span>
	            </dt>
	            <dd><code>plus(acc,x)</code> is equivalent to <code>acc+x</code>.</dd>
	            <dd class="example">
					<p>
						<code>[1,2,3,4,5].reduce(plus);</code>
						<br/><span class="output"><code>15</code></span>
					</p>
				</dd>
	            
	            <dt>
	                times
	                <ul class="arguments">
				        <li>acc</li>
				        <li>x</li>
				    </ul>
				     <span class="return">number</span>
	            </dt>
	            <dd><code>times(acc,x)</code> is equivalent to <code>acc*x</code>.</dd>
	            <dd class="example">
					<p>
						<code>[1,2,3,4,5].reduce(times);</code>
						<br/><span class="output"><code>120</code></span>
					</p>
				</dd>
	            
	            <dt>
	                count
	                <ul class="arguments">
				        <li class="optional">predicate</li>
				    </ul>
				     <span class="return">function</span>
	            </dt>
	            <dd><p><code>count()</code> is a reduction function that counts the number of elements in the reduced collection. When reducing an Array, the value <code>0</code> should be passed as the initial value.</p></dd>
	            <dd class="example">
					<p>
						<code>[1,2,3,4,5].reduce(count(),0);</code>
						<br/><span class="output"><code>5</code></span>
					</p>
				</dd>
				<dd><p><code>count(predicate)</code> is a reduction function that counts the number of elements in the reduced collection that match the predicate.</p></dd>
	            <dd class="example">
					<p>
						<code>
						    function even (x) { return x % 2 === 0; }
						    <br/>[1,2,3,4,5].reduce(count(even),0);
						</code>
						<br/><span class="output"><code>2</code></span>
					</p>
				</dd>
	            
	            <dt>
	                withmethod
	                <ul class="arguments unbounded">
				        <li>name</li>
				        <li class="optional">a</li>
				        <li class="optional">b</li>
				        <li class="optional">c</li>
				    </ul>
				     <span class="return">function</span>
	            </dt>
	            <dd class="example">
					<p>
						<code>
						    [[1,2,3],[4,5],[6,7,8]].reduce(withmethod('concat'),[]);
						</code>
						<br/><span class="output"><code>[1, 2, 3, 4, 5, 6, 7, 8]</code></span>
					</p>
				</dd>
	            
	            <dt>
	                push
	            </dt>
	            
	            <dt>
	                add
	            </dt>
	            
	            <dt>
	                contains
					<ul class="arguments">
				        <li>predicate</li>
				    </ul>
				     <span class="return">function</span>
	            </dt>
				<dd class="example">
					<p>
						<code>
						    function even (x) { return x % 2 === 0; }
						    <br/>[1,2,3,4,5].reduce(contains(even),false);
						</code>
						<br/><span class="output"><code>true</code></span>
						<br/><code>[1,3,5].reduce(contains(even),false);</code>
						<br/><span class="output"><code>false</code></span>
					</p>
				</dd>
	            
	            <dt>
	                max
	            </dt>
				<dd class="example">
					<p>
						<code>[3,4,5,1,2].reduce(max);
						</code>
						<br/><span class="output"><code>5</code></span>
					</p>
					<p>
						<code>['red','green','blue'].reduce(max);
						</code>
						<br/><span class="output"><code>"red"</code></span>
					</p>
				</dd>
	            
	            <dt>
	                min
	            </dt>
				<dd class="example">
					<p>
						<code>[3,4,5,1,2].reduce(min);
						</code>
						<br/><span class="output"><code>1</code></span>
					</p>
					<p>
						<code>['red','green','blue'].reduce(min);
						</code>
						<br/><span class="output"><code>"blue"</code></span>
					</p>
				</dd>
		        
		    </dl>
		    
		</article>
		
		<article>
		    
		    <h1>Predicates</h1>
		    <dl>
		        
		        <dt>
	                valid
	            </dt>
	            
	            <dt>
	                is
	            </dt>
	            
	            <dt>
	                is_of_type
	                <ul class="arguments">
    			         <li>type</li>
    			     </ul>
    				<span class="return">predicate</span>
	            </dt>
	            <dd><p><code>is_of_type(<var>type</var>)</code> matches candidates whose type is <code><var>type</var></code>.</p></dd>
				<dd class="example">
					<p>
						<code>is_of_type('string')('test');</code>
						<br/><span class="output"><code>true</code></span>
					</p>
					<p>
						<code>is_of_type('string')(4);</code>
						<br/><span class="output"><code>false</code></span>
					</p>
					<p>
						<code>if_of_type('number')(4);</code>
						<br/><span class="output"><code>true</code></span>
					</p>
				</dd>
	            
	            <dt>
	                isa
	                 <ul class="arguments">
    			         <li>constructor</li>
    			     </ul>
    				<span class="return">predicate</span>
    				<ul class="aliases">
    				    <li>opal.isan</li>
    				</ul>
	            </dt>
	            <dd><p><code>isa(constructor)</code> matches candidates whose constructor function is <code>constructor</code>.</p></dd>
				<dd class="example">
					<p>
						<code>isa(Array)('test');</code>
						<br/><span class="output"><code>false</code></span>
					</p>
					<p>
						<code>isa(Array)([1,2,3]);</code>
						<br/><span class="output"><code>true</code></span>
					</p>
				</dd>
	            
	            <dt>
	                has
	            </dt>
	            
	            <dt>
	                compare
	            </dt>
	            
	            <dt>
	                eq
					<ul class="arguments">
    			         <li>value</li>
    			     </ul>
    				<span class="return">predicate</span>
	            </dt>
				<dd><p><code>eq(value)</code> matches candidates which are equal to <code>value</code> (including type).</p></dd>
				<dd class="example">
					<p>
						<code>eq(4)(4);</code>
						<br/><span class="output"><code>true</code></span>
					</p>
					<p>
						<code>eq(4)(5);</code>
						<br/><span class="output"><code>false</code></span>
					</p>
					<p>
						<code>eq('red')('red');</code>
						<br/><span class="output"><code>true</code></span>
					</p>
				</dd>
	            
	            <dt>
	                neq
					<ul class="arguments">
    			         <li>value</li>
    			     </ul>
    				<span class="return">predicate</span>
	            </dt>
				<dd><p><code>neq(value)</code> matches candidates which are not equal to <code>value</code> (including type).</p></dd>
				<dd class="example">
					<p>
						<code>neq(4)(4);</code>
						<br/><span class="output"><code>false</code></span>
					</p>
					<p>
						<code>neq(4)(5);</code>
						<br/><span class="output"><code>true</code></span>
					</p>
					<p>
						<code>neq('red')('red');</code>
						<br/><span class="output"><code>false</code></span>
					</p>
					<p>
						<code>neq('red')('green');</code>
						<br/><span class="output"><code>true</code></span>
					</p>
				</dd>
	            
	            <dt>
	                lt
	            </dt>
	            
	            <dt>
	                gt
	            </dt>
	            
	            <dt>
	                lte
	            </dt>
	            
	            <dt>
	                gte
	            </dt>
	            
	            <dt>
	                between
	            </dt>
	            
	            <dt>
	                regex
	            </dt>
	            
	            <dt>
	                istrue
	            </dt>
	            
	            <dt>
	                isnull
	            </dt>
		        
		    </dl>
		    
		</article>
		
		<article>
		    
		    <h1>EnhancedObject</h1>
		    <dl>
		        
		        <dt>
		            <span class="keyword">new</span>
		            EnhancedObject
		            <ul class="arguments">
				        <li/>
				    </ul>
		        </dt>
		        
		        <dt>
		            EnhancedObject.from
		            <ul class="arguments">
				        <li>object</li>
				    </ul>
				    <span class="return">EnhancedObject</span>
		        </dt>
		        
		        <dt>
	                <span class="object">obj</span>.addProperties
	                <ul class="arguments">
				        <li>properties</li>
				    </ul>
				    <span class="return">obj</span>
	            </dt>
	            
	            <dt>
	                <span class="object">obj</span>.removeProperties
	                <ul class="arguments unbounded">
				        <li>name1</li>
				        <li>name2</li>
				        <li>name3</li>
				    </ul>
				    <span class="return">obj</span>
	            </dt>
	            
	            <dt>
	                <span class="object">obj</span>.defaults
	                <ul class="arguments">
				        <li>properties</li>
				    </ul>
				    <span class="return">obj</span>
	            </dt>
	            
	            <dt>
	                <span class="object">obj</span>.setProperty
	                <ul class="arguments">
				        <li>name</li>
				        <li>value</li>
				    </ul>
				    <span class="return">obj</span>
	            </dt>
		        
		    </dl>
		    
		</article>
		
		<article>
		    
		    <h1>Nullable</h1>
		    <dl>
		        
		        <dt>
		            Nullable
		            <ul class="arguments">
				        <li>constructor</li>
				    </ul>
		        </dt>
		        
		    </dl>
		    
		</article>	
		
		<article>
		    
		    <h1>Utility functions</h1>
		    <dl>
		        
		        <dt>
	                type
	                <ul class="arguments">
    			         <li>value</li>
    			     </ul>
    				<span class="return">string</span>
	            </dt>
	            <dd><p><code>type</code> encapsulates the <code>typeof</code> operator in a function.</p></dd>
				<dd class="example">
					<p>
						<code>type('test');</code>
						<br/><span class="output"><code>"string"</code></span>
					</p>
					<p>
						<code>type({name:'john'});</code>
						<br/><span class="output"><code>"object"</code></span>
					</p>
				</dd>
		        
		        <dt>
	                copy
	            </dt>
	            
	            <dt>
	                arg
	            </dt>
	            
	            <dt>
	                first, second, third
	            </dt>
	            
	            <dt>
	                _0, _1, _2, _3, _4, _5
	            </dt>
	            
	            <dt>
	                assert
	            </dt>
	            
	            <dt>
	                delegateTo
	            </dt>
		        
		    </dl>
		    
		</article>
		
		
		<!-- Old -->
		<h1 style="background: red; padding: 8px; margin-top: 32px;">Old</h1>
		
		<article>
			<h2>Object Functions</h2>
		
			<dl>		
			
				<dt>
					<code>
						<span class="name">Resolve</span>
						<span class="arguments">(name<span class="optional">,value</span>)</span>
					</code>
					<span class="return">→ <span class="type">(object → value)</span></span>
				</dt>
				<dd><span style="color:red">document this</span></dd>
			
				<dt>
					<code>
						<span class="name">transform</span>
						<span class="arguments">(name,transformer)</span>
					</code>
					<span class="return">→ 
						<span class="type">(object → object)</span>
					</span>
				</dt>
				<dd><span style="color:red">document this</span></dd>
			
			</dl>
		</article>
		
		<article>
			<h2>Predicates</h2>
		
			<dl>
				
				<dd><span style="color:red">document this</span></dd>
			
				<dt>
					<code>
						<span class="name">AllPredicate</span>
						<span class="arguments">(value)</span>
					</code>
					<span class="return">→ <span class="type">boolean</span></span>
				</dt>
				<dd><p><code>AllPredicate</code> matches all candidates.</p></dd>
				<dd class="example">
					<p>
						<code>AllPredicate('test');</code>
						<br/><span class="output"><code>true</code></span>
					</p>
					<p>
						<code>AllPredicate(7);</code>
						<br/><span class="output"><code>true</code></span>
					</p>
					<p>
						<code>AllPredicate(false);</code>
						<br/><span class="output"><code>true</code></span>
					</p>
					<p>
						<code>AllPredicate(null);</code>
						<br/><span class="output"><code>true</code></span>
					</p>
				</dd>
			
				<dt>
					<code>
						<span class="name">NonePredicate</span>
						<span class="arguments">(value)</span>
					</code>
					<span class="return">→ <span class="type">boolean</span></span>
				</dt>
				<dd><p><code>NonePredicate</code> matches no candidates.</p></dd>
				<dd class="example">
					<p>
						<code>NonePredicate('test');</code>
						<br/><span class="output"><code>false</code></span>
					</p>
					<p>
						<code>NonePredicate(7);</code>
						<br/><span class="output"><code>false</code></span>
					</p>
					<p>
						<code>NonePredicate(true);</code>
						<br/><span class="output"><code>false</code></span>
					</p>
					<p>
						<code>NonePredicate(null);</code>
						<br/><span class="output"><code>false</code></span>
					</p>
				</dd>
			
				<dt>
					<code>
						<span class="name">TruePredicate</span>
						<span class="arguments">(value)</span>
					</code>
					<span class="return">→ <span class="type">boolean</span></span>
				</dt>
				<dd><p><code>TruePredicate</code> matches the boolean value <code>true</code>.</p></dd>
				<dd class="example">
					<p>
						<code>TruePredicate('test');</code>
						<br/><span class="output"><code>false</code></span>
					</p>
					<p>
						<code>TruePredicate(7);</code>
						<br/><span class="output"><code>false</code></span>
					</p>
					<p>
						<code>TruePredicate(true);</code>
						<br/><span class="output"><code>true</code></span>
					</p>
					<p>
						<code>TruePredicate(false);</code>
						<br/><span class="output"><code>false</code></span>
					</p>
					<p>
						<code>TruePredicate(null);</code>
						<br/><span class="output"><code>false</code></span>
					</p>
				</dd>
			
				<dt>
					<code>
						<span class="name">FunctionPredicate</span>
						<span class="arguments">(fn)</span>
					</code>
					<span class="return">→ <span class="type">(value → boolean)</span></span>
				</dt>
				<dd><span style="color:red">document this</span></dd>
			
				<dt>
					<code>
						<span class="name">FunctionValuePredicate</span>
						<span class="arguments">(fn,value)</span>
					</code>
					<span class="return">→ <span class="type">(value → boolean)</span></span>
				</dt>
				<dd><span style="color:red">document this</span></dd>
			
				<dt><code>ObjectIdentityPredicate <span class="arguments">(object)</span></code></dt>
				<dd><p><code>ObjectIdentityPredicate(object)</code> matches the candidate if the candidate is the same object as <code>object</code>.</p></dd>
				<dd class="example">
					<p>
						<code>var person = {forename:'john',surname:'smith'};
						<br/>ObjectIdentityPredicate(person)(person);</code>
						<br/><span class="output"><code>true</code></span>
						<br/><code>ObjectIdentityPredicate(person)({forename:'john',surname:'smith'});</code>
						<br/><span class="output"><code>false</code></span>
					</p>
				</dd>
			
			</dl>
		</article>
		
		
		<article>
			<h2>Orderings</h2>
		
			<dl>
			
				<dt><code>PredicateOrdering <span class="arguments">(predicate1,predicate2...)</span></code></dt>
				<dd><span style="color:red">document this</span></dd>
			
			</dl>
		</article>
		
		
		<article>
			<h2>Reduction Functions</h2>
		
			<dl>
			
				<dt><code>push <span class="arguments">(a,b)</span></code></dt>
				<span style="color:red">document this</span>
			
				<dt><code>add <span class="arguments">(predicate,mapping)</span></code></dt>
				<span style="color:red">document this</span>
			
				<dt><code>contains <span class="arguments">(predicate)</span></code></dt>
				<span style="color:red">document this</span>
		
			</dl>
		</article>
		
	

		<article>
			<h2>Utility Functions</h2>
		
			<dl>
			
				<dt><code>extend <span class="arguments">(object,target)</span></code></dt>
				<dd><span style="color:red">document this</span></dd>
			
				<dt><code>copy <span class="arguments">(object,exact)</span></code></dt>
				<dd><span style="color:red">document this</span></dd>
			
			</dl>
		</article>
		
	</body>
</html>
